<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>为什么选择 Netty 而不是原生 NIO</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
            min-height: 100vh;
        }
        
        .hero-gradient {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        
        .card-hover {
            transition: all 0.3s ease;
            border: 2px solid transparent;
        }
        
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
            border-color: #667eea;
        }
        
        .feature-icon {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
        }
        
        .section-title {
            position: relative;
            padding-left: 20px;
        }
        
        .section-title::before {
            content: '';
            position: absolute;
            left: 0;
            top: 50%;
            transform: translateY(-50%);
            width: 4px;
            height: 30px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            border-radius: 2px;
        }
        
        .comparison-card {
            background: rgba(255, 255, 255, 0.95);
            backdrop-filter: blur(10px);
            border-radius: 16px;
            padding: 24px;
            margin-bottom: 16px;
            transition: all 0.3s ease;
        }
        
        .comparison-card:hover {
            transform: translateX(5px);
            box-shadow: 0 10px 30px rgba(102, 126, 234, 0.1);
        }
        
        .badge {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 4px 12px;
            border-radius: 20px;
            font-size: 12px;
            font-weight: 500;
            display: inline-block;
            margin-bottom: 8px;
        }
        
        .mermaid {
            display: flex;
            justify-content: center;
            margin: 40px 0;
        }
        
        .highlight-text {
            background: linear-gradient(to right, rgba(102, 126, 234, 0.1), rgba(118, 75, 162, 0.1));
            padding: 2px 8px;
            border-radius: 4px;
            font-weight: 500;
        }
        
        @keyframes fadeInUp {
            from {
                opacity: 0;
                transform: translateY(30px);
            }
            to {
                opacity: 1;
                transform: translateY(0);
            }
        }
        
        .animate-fadeInUp {
            animation: fadeInUp 0.8s ease-out;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <div class="hero-gradient text-white py-20 px-6">
        <div class="max-w-6xl mx-auto text-center animate-fadeInUp">
            <h1 class="text-5xl md:text-6xl font-bold mb-6" style="font-family: 'Noto Serif SC', serif;">
                为什么选择 <span class="text-yellow-300">Netty</span>
            </h1>
            <p class="text-xl md:text-2xl mb-8 opacity-90">
                而不是原生 NIO？
            </p>
            <div class="max-w-3xl mx-auto">
                <p class="text-lg leading-relaxed opacity-80">
                    选择 Netty 而不是原生 NIO 的主要原因在于其简化的编程模型、高性能和可扩展性、丰富的功能和社区支持。Netty 通过封装底层复杂性和提供高级功能，使得网络编程变得更加高效、便捷和可靠。
                </p>
            </div>
        </div>
    </div>

    <!-- Main Content -->
    <div class="max-w-6xl mx-auto px-6 py-12">
        <!-- Overview Cards -->
        <div class="grid md:grid-cols-3 gap-6 mb-16">
            <div class="card-hover bg-white rounded-xl p-6 text-center">
                <i class="fas fa-code text-4xl feature-icon mb-4"></i>
                <h3 class="text-xl font-bold mb-2">简化编程</h3>
                <p class="text-gray-600">高层抽象，隐藏底层复杂性</p>
            </div>
            <div class="card-hover bg-white rounded-xl p-6 text-center">
                <i class="fas fa-rocket text-4xl feature-icon mb-4"></i>
                <h3 class="text-xl font-bold mb-2">高性能</h3>
                <p class="text-gray-600">优化的 I/O 模型和内存管理</p>
            </div>
            <div class="card-hover bg-white rounded-xl p-6 text-center">
                <i class="fas fa-puzzle-piece text-4xl feature-icon mb-4"></i>
                <h3 class="text-xl font-bold mb-2">功能丰富</h3>
                <p class="text-gray-600">开箱即用的高级功能</p>
            </div>
        </div>

        <!-- Comparison Visualization -->
        <div class="bg-white rounded-2xl p-8 mb-16 shadow-lg">
            <h2 class="text-3xl font-bold mb-8 text-center">Netty vs 原生 NIO 对比图</h2>
            <div class="mermaid">
                graph TD
                    A[网络编程需求] --> B{选择框架}
                    B --> C[原生 NIO]
                    B --> D[Netty]
                    
                    C --> E[复杂的底层编程]
                    C --> F[手动管理连接]
                    C --> G[自行实现高级功能]
                    C --> H[有限的社区支持]
                    
                    D --> I[简化的编程模型]
                    D --> J[自动连接管理]
                    D --> K[丰富的内置功能]
                    D --> L[活跃的社区生态]
                    
                    I --> M[更快的开发速度]
                    J --> M
                    K --> M
                    L --> M
                    
                    E --> N[开发效率低]
                    F --> N
                    G --> N
                    H --> N
                    
                    style D fill:#667eea,stroke:#764ba2,stroke-width:3px,color:#fff
                    style M fill:#48bb78,stroke:#38a169,stroke-width:2px,color:#fff
                    style N fill:#f56565,stroke:#e53e3e,stroke-width:2px,color:#fff
            </div>
        </div>

        <!-- Detailed Comparisons -->
        <div class="space-y-12">
            <!-- 1. 简化了编程模型 -->
            <div>
                <h2 class="section-title text-3xl font-bold mb-6">
                    <i class="fas fa-layer-group mr-3 text-purple-600"></i>
                    1. 简化了编程模型
                </h2>
                <div class="grid md:grid-cols-2 gap-6">
                    <div class="comparison-card">
                        <span class="badge">原生 NIO</span>
                        <h4 class="text-xl font-semibold mb-3">复杂的底层 API</h4>
                        <p class="text-gray-700 leading-relaxed">
                            原生 NIO API 提供了 <code class="highlight-text">Selector</code>、<code class="highlight-text">Channel</code> 和 <code class="highlight-text">Buffer</code> 等类来进行非阻塞 I/O 操作。虽然这些 API 强大，但它们也相对复杂，特别是在处理连接管理、事件循环和多线程方面。开发者需要手动管理和编写大量的底层代码来实现基本的功能。
                        </p>
                    </div>
                    <div class="comparison-card">
                        <span class="badge">Netty</span>
                        <h4 class="text-xl font-semibold mb-3">高层抽象封装</h4>
                        <p class="text-gray-700 leading-relaxed">
                            Netty 封装了这些底层 API，提供了高层的抽象和简化的编程模型。它隐藏了很多底层的复杂性，使得网络编程变得更加直观和易于使用。Netty 提供了丰富的 API 和工具来处理连接、数据编解码、事件管理等，使得开发者能够更专注于业务逻辑。
                        </p>
                    </div>
                </div>
            </div>

            <!-- 2. 高性能和可扩展性 -->
            <div>
                <h2 class="section-title text-3xl font-bold mb-6">
                    <i class="fas fa-tachometer-alt mr-3 text-purple-600"></i>
                    2. 高性能和可扩展性
                </h2>
                <div class="grid md:grid-cols-2 gap-6">
                    <div class="comparison-card">
                        <span class="badge">原生 NIO</span>
                        <h4 class="text-xl font-semibold mb-3">需要手动优化</h4>
                        <p class="text-gray-700 leading-relaxed">
                            尽管原生 NIO 提供了非阻塞 I/O 的支持，但在高负载或大规模并发连接时，开发者需要自行优化和调整参数，以达到最佳性能。这可能涉及复杂的配置和调优工作。
                        </p>
                    </div>
                    <div class="comparison-card">
                        <span class="badge">Netty</span>
                        <h4 class="text-xl font-semibold mb-3">内置性能优化</h4>
                        <p class="text-gray-700 leading-relaxed">
                            Netty 在性能方面经过了高度优化，采用了高效的 I/O 线程模型（如 Reactor 模式）和优化的内存管理机制（如池化技术）。Netty 的设计目标之一就是提供高性能的网络通信框架，能够处理大量并发连接而不会造成性能瓶颈。
                        </p>
                    </div>
                </div>
            </div>

            <!-- 3. 丰富的功能和灵活的扩展 -->
            <div>
                <h2 class="section-title text-3xl font-bold mb-6">
                    <i class="fas fa-plug mr-3 text-purple-600"></i>
                    3. 丰富的功能和灵活的扩展
                </h2>
                <div class="grid md:grid-cols-2 gap-6">
                    <div class="comparison-card">
                        <span class="badge">原生 NIO</span>
                        <h4 class="text-xl font-semibold mb-3">基础 I/O 功能</h4>
                        <p class="text-gray-700 leading-relaxed">
                            原生 NIO 主要关注基础的 I/O 操作。要实现高级功能，如协议编解码、数据压缩、加密、负载均衡等，开发者需要自行实现或寻找其他库。
                        </p>
                    </div>
                    <div class="comparison-card">
                        <span class="badge">Netty</span>
                        <h4 class="text-xl font-semibold mb-3">开箱即用的高级功能</h4>
                        <p class="text-gray-700 leading-relaxed">
                            Netty 提供了许多开箱即用的功能，如协议编解码（支持多种常见协议）、数据压缩、加密、负载均衡、服务发现等。Netty 的设计允许开发者通过插件和扩展机制轻松集成各种功能，而无需从头开始编写复杂的代码。
                        </p>
                    </div>
                </div>
            </div>

            <!-- 4. 强大的社区和文档支持 -->
            <div>
                <h2 class="section-title text-3xl font-bold mb-6">
                    <i class="fas fa-users mr-3 text-purple-600"></i>
                    4. 强大的社区和文档支持
                </h2>
                <div class="grid md:grid-cols-2 gap-6">
                    <div class="comparison-card">
                        <span class="badge">原生 NIO</span>
                        <h4 class="text-xl font-semibold mb-3">有限的资源</h4>
                        <p class="text-gray-700 leading-relaxed">
                            原生 NIO 的文档和社区支持相对有限。虽然 Java 标准库提供了基本的文档，但对于复杂的应用场景，开发者往往需要依赖于